Currently almost no passes assume that the type field of an expression is correct.
This is not wrong, but it is not useful either.

We are developing an interpreter in which we are building up expressions that use the P4C IR. To simplify these expression we reuse some of the compiler passes, primarily StrengthReduction and ConstantFolding. They are quite useful since they handle a lot of cases and can be applied without needing a type or reference map. However, sometimes the results are missing type information, which the interpreter requires. By adding this type information we avoid running into this issue.

This will only store type information in some literals, not even sure that in all of them.
You already know that all Bool literals have type bool, there's no choice there.
Other literals won't have type information, e.g., strings, enum, errors, etc.
Recall that we also have another symbolic interpreter for loop unrolling which does some of this work.

Yes, the problem was that well-typed expressions such as IR::Equ were reduced to a literal that had no type. The interpreter relies on ->type to be correct since at that particular stage it just works with IR::Expression objects. Another way to solve this were to explicitly check the returned expression from ConstantFolding and manually assign types. But that fix would be cumbersome since we would need to do this for all sorts of expressions. It was easier to just edit ConstantFolding.

For ConstantFolding I was only able to identify these literals without a type, but there might be more.